package com.tangkeyon.service.impl;

import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.tangkeyon.common.ResponseCode;
import com.tangkeyon.dao.CategoryMapper;
import com.tangkeyon.pojo.Category;
import com.tangkeyon.service.ICategoryService;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Set;

/**
 * @Author: tangkeyon@gmail.com
 * @Date: 2019/5/27 20:34
 * @Version 1.0
 */
@Service("iCategoryService")
public class ICategoryServiceImpl implements ICategoryService {
    @Autowired
    private CategoryMapper categoryMapper;

    @Override
    public ResponseCode addCategory(String categoryName, Integer parentId) {
        if (StringUtils.isNotBlank(categoryName)) {
            Category insertCategory = new Category();
            insertCategory.setName(categoryName);
            insertCategory.setParentId(parentId);
            insertCategory.setStatus(true);

//             添加元素都会为对象的各个属性赋值，因此在这里选择使用全字段添加方法
            int resultCount = categoryMapper.insert(insertCategory);
            if (resultCount == 0) {
                return ResponseCode.createByErrorMessage("添加失败");
            }
            return ResponseCode.creatBySuccessMessage("添加成功");
        }
        return ResponseCode.createByErrorMessage("传入的参数为空");
    }

    @Override
    public ResponseCode updateCategory(String newName, Integer id) {
        if (StringUtils.isNotBlank(newName)) {
            Category updateCategory = new Category();
            updateCategory.setName(newName);
            updateCategory.setId(id);
            int resultCount = categoryMapper.updateByPrimaryKeySelective(updateCategory);
            if (resultCount == 0) {
                return ResponseCode.createByErrorMessage("修改失败");
            }
            return ResponseCode.creatBySuccessMessage("修改成功");
        }
        return ResponseCode.createByErrorMessage("传入的参数为空");
    }

    @Override
    public ResponseCode<List<Category>> selectParallelChildCategory(Integer categoryId) {
//        查询节点下的二级节点只需要将传入的categoryId作为parentId进行查询即可
        List<Category> categoryList = categoryMapper.selectCategoryByParentId(categoryId);
        if(CollectionUtils.isEmpty(categoryList)){
            return  ResponseCode.createByErrorMessage("未找到二级类别");
        }
        return  ResponseCode.creatBySuccess(categoryList);
    }

    /**
     * 查出categoryId对应的节点及其所属的无限层级子节点
     * @param categoryId
     * @return
     */
    @Override
    public ResponseCode<List<Integer>> selectAllLevelChildCategory(Integer categoryId) {
        Set<Category> categorySet= Sets.newHashSet();
//        将集合的实例化对象作为参数传入递归方法中，可以通过接受递归方法的返回值来获得添加了数据的集合
//        也可以直接引用这个集合，因为集合是地址传递，在调用了递归函数后集合内部已经有值了
        findChildCategory(categorySet,categoryId);
        List<Integer> categoryList= Lists.newArrayList();
        for(Category item:categorySet){
            categoryList.add(item.getId());
        }
        if(categoryList.size()==0){
            return  ResponseCode.createByErrorMessage("没有查询到节点");
        }
        return ResponseCode.creatBySuccess(categoryList);
    }

//    递归查找节点下的所有子节点
    private Set<Category> findChildCategory(Set<Category>set,Integer categoryId){
//        根据categoryId查询出对应的category
        Category category = categoryMapper.selectByPrimaryKey(categoryId);
        if(category !=null){
            set.add(category);
        }
//        查询category下的全部二级节点
        List<Category> categoryList = categoryMapper.selectCategoryByParentId(categoryId);
        for(Category item:categoryList){
//            二级节点下可能还有更多层级的节点，不管有没有先进行迭代
//            如果有的话会进入更深一层的迭代，如果没有这将作为递归的终止条件
            findChildCategory(set,item.getId());
        }
        return set;

    }
}
